﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp20
{
    class Student
    {
        private int stno;
        private string name;
        private int age;
        public int Stno
        {
            get { return this.stno; }
            set { this.stno = value; }
        }
        public string Name
        {
            get { return this.name; }
            set { this.name = value; }
        }
        public int Age
        {
            get { return this.age; }
            set { this.age = value; }
        }
        public Student(int stno, string name, int age)
        {
            Stno = stno;
            Name = name;
            Age = age;
        }
        public override string ToString()
        {
            return $"学号：{Stno}  姓名：{Name} 年龄：{Age}  ";
        }

    }
    class StnoSort : IComparer<Student>
    {
        public int Compare(Student x, Student y)
        {
            //if (x.Stno > y.Stno)
            //{
            //    return 1;
            //}
            //else
            //{
            //    return -1;
            //}
            return x.Stno.CompareTo(y.Stno);
        }
    }
    class NameSort : IComparer<Student>
    {
        public int Compare(Student x, Student y)
        {
            //if (x.Name > y.Name)
            //{
            //    return 1;
            //}
            //else
            //{
            //    return -1;
            //}
            return x.Name.CompareTo(y.Name);
        }
    }
    class AgeSort : IComparer<Student>
    {
        public int Compare(Student x, Student y)
        {
            //if (x.Age > y.Age)
            //{
            //    return 1;
            //}
            //else
            //{
            //    return -1;
            //}
            return x.Age.CompareTo(y.Age);
        }
    }
    /// <summary>
    /// -------------------------------------------------------------------------------------------------------------
    /// </summary>
    class ASD
    {
        private double r;
        private int c;
        private int k;
        public double R
        {
            get { return this.r; }
            set { this.r = value; }
        }
        public int C
        {
            get { return this.c; }
            set { this.c = value; }
        }
        public int K
        {
            get { return this.k; }
            set { this.k = value; }
        }

        /// <summary>
        /// 圆面积
        /// </summary>
        /// <param name="r">半径</param>
        /// <returns>圆面积</returns>
        public double aaa(double r)
        {
            this.r = r;
            return 3.14 * this.r * this.r;
        }

        /// <summary>
        /// 长方形面积
        /// </summary>
        /// <param name="c">长</param>
        /// <param name="k">宽</param>
        /// <returns>长方形面积</returns>
        public int aaa(int c, int k)
        {
            this.c = c;
            this.k = k;
            return this.c * this.k;
        }
    }



    class SumUrils
    {
        private int a;
        private int b;
        private double c;
        private double d;
        private string e;
        private string f;
        private int g;

        public int A
        {
            get { return this.a; }
            set { this.a = value; }
        }
        public int B
        {
            get { return this.b; }
            set { this.b = value; }
        }
        public double C
        {
            get { return this.c; }
            set { this.c = value; }
        }
        public double D
        {
            get { return this.d; }
            set { this.d = value; }
        }
        public string E
        {
            get { return this.e; }
            set { this.e = value; }
        }
        public string F
        {
            get { return this.f; }
            set { this.f = value; }
        }
        public int G
        {
            get { return this.g; }
            set { this.g = value; }
        }

        public int AAA(int a, int b)
        {
            this.a = a;
            this.b = b;
            return this.a + this.b;
        }
        public double AAA(double c, double d)
        {
            this.c = c;
            this.d = d;
            return this.c + this.d;
        }
        public string AAA(string e, string f)
        {
            this.e = e;
            this.f = f;
            return this.e + this.f;
        }
        public int AAA(int g)
        {
            int sum = 0;
            for (int i = 1; i <= g; i++)
            {
                sum = sum + i;
            }
            return sum;
        }
    }
    /// <summary>
    /// -------------------------------------------------------------------------------------------------------------
    /// </summary>
    class Employee
    {
        private int id;
        private string name;
        private string mas;

        public int Id
        {
            get { return this.id; }
            set { this.id = value; }
        }
        public string Name
        {
            get { return this.name; }
            set { this.name = value; }
        }
        public string Mas
        {
            get { return this.mas; }
            set { this.mas = value; }
        }

        public void aaa()
        {
            Console.WriteLine("我的工号是{0},我的姓名是{1},我的部门是{2}", this.Id, this.Name, this.Mas);
        }
        public void bbb(int Id, string Name, string Mas)
        {
            Console.WriteLine("我的工号是{0},我的姓名是{1},我的部门是{2}", Id, Name, Mas);
        }
    }
    /// <summary>
    /// -------------------------------------------------------------------------------------------------------------
    /// </summary>
    class Animal
    {
        private string name;
        private string sex;

        public string Sex { get => sex; set => sex = value; }
        public string Name { get => name; set => name = value; }
        public Animal(string name, string sex)
        {
            this.name = name;
            this.sex = sex;
        }
        public Animal()
        {
        }
    }
    interface IClimb
    {
        void Climb();
    }
    interface IEat
    {
        void Eat();
    }
    interface ISwim
    {
        void Swim();
    }
    class Cat : Animal, IClimb, IEat, ISwim
    {
        public void Climb()
        {
            Console.WriteLine("猫爬树");
        }
        public void Eat()
        {
            Console.WriteLine("猫吃粮");
        }
        public void Swim()
        {
            Console.WriteLine("猫游泳");
        }
        public void Play()
        {
            Console.WriteLine("名字叫{0}，性别为{1}的小猫正在玩毛球", this.Name, this.Sex);
        }
        public Cat(string name, string sex) : base(name, sex)
        {

        }
    }
    class Dog : Animal, ISwim, IEat
    {
        public void Swim()
        {
            Console.WriteLine("狗在狗刨游泳");
        }
        public void Eat()
        {
            Console.WriteLine("狗吃粮");
        }
        public void Play()
        {
            Console.WriteLine("名字叫{0}，性别为{1}的小狗正在捡木棍", this.Name, this.Sex);
        }
        public Dog(string name, string sex) : base(name, sex)
        {

        }
    }
    class Duck : Animal, ISwim, IEat
    {
        public void Swim()
        {
            Console.WriteLine("鸭子游泳");
        }
        public void Eat()
        {
            Console.WriteLine("鸭子吃饭");
        }
        public void Play()
        {
            Console.WriteLine("名字叫{0}，性别为{1}的小鸭正在玩水", this.Name, this.Sex);
        }
        public Duck(string name, string sex) : base(name, sex)
        {

        }
    }
    class Monkey : Animal, IClimb, IEat
    {
        public void Climb()
        {
            Console.WriteLine("猴子爬树");
        }
        public void Eat()
        {
            Console.WriteLine("猴子吃桃");
        }
        public void Play()
        {
            Console.WriteLine("名字叫{0}，性别为{1}的小猴正在荡秋千", this.Name, this.Sex);
        }
        public Monkey(string name, string sex) : base(name, sex)
        {

        }
    }


    interface IExpedite
    {
        void Expedite();
    }
    interface IFly
    {
        void Fly();
    }
    interface IFire : IFly
    {
        void Fly();
        void Fire();
    }
    class Car
    {
        private string brand;
        private string type;

        public string Brand
        {
            get { return this.brand; }
            set { this.brand = value; }
        }

        public string Type
        {
            get { return this.type; }
            set { this.type = value; }
        }

        public Car(string brand, string type)
        {
            this.brand = brand;
            this.type = type;
        }
        public Car()
        {
        }
        public void Run()
        {
            Console.WriteLine("一辆品牌是{0}，型号是{1}的车在奔跑", this.brand, this.type);
        }
    }
    class Batmobile : Car, IFly, IFire, IExpedite
    {
        public void Fire()
        {
            Console.WriteLine("一辆品牌是{0}，型号是{1}的车在喷火", base.Brand, this.Type);
        }
        public void Fly()
        {
            Console.WriteLine("一辆品牌是{0}，型号是{1}的车在飞行", base.Brand, this.Type);
        }
        public void Expedite()
        {
            Console.WriteLine("一辆品牌是{0}，型号是{1}的车在加速", base.Brand, this.Type);
        }
        public Batmobile(string brand, string type) : base(brand, type)
        {

        }
    }
    class BMWCar : Car, IExpedite
    {
        public void Expedite()
        {
            Console.WriteLine("一辆品牌是{0}，型号是{1}的车在加速", base.Brand, this.Type);
        }
        public BMWCar(string brand, string type) : base(brand, type)
        {

        }
    }


    class Flight//飞行
    {
        private string name;
        public string Name { get => name; set => name = value; }
        public Flight(string name)
        {
            this.name = name;
        }
        public Flight()
        {

        }
    }
    interface IFly1//冲突暂时后面加1
    {
        void Fly();
    }
    interface ILand
    {
        void Land();
    }
    interface IEat1//冲突暂时后面加1
    {
        void Eat();
    }
    class Superman : Flight, IFly1, ILand, IEat1
    {
        public void Fly()
        {
            Console.WriteLine("姓名叫{0}的超人正在飞行", this.Name);
        }
        public void Land()
        {
            Console.WriteLine("姓名叫{0}的超人正在着陆", this.Name);
        }
        public void Eat()
        {
            Console.WriteLine("姓名叫{0}的超人正在吃饭", this.Name);
        }
        public Superman(string name) : base(name)
        {

        }
    }
    class Bird : Flight, IFly1, ILand, IEat1
    {
        public void Fly()
        {
            Console.WriteLine("名叫{0}的小鸟正在飞行", this.Name);
        }
        public void Land()
        {
            Console.WriteLine("名叫{0}的小鸟正在着陆", this.Name);
        }
        public void Eat()
        {
            Console.WriteLine("名叫{0}的小鸟正在吃虫", this.Name);
        }
        public Bird(string name) : base(name)
        {

        }
    }
    class Plane : Flight, IFly1, ILand, IEat1
    {
        public void Fly()
        {
            Console.WriteLine("名叫{0}的战斗机正在飞行", this.Name);
        }
        public void Land()
        {
            Console.WriteLine("名叫{0}的战斗机正在着陆", this.Name);
        }
        public void Eat()
        {
            Console.WriteLine("名叫{0}的战斗机正在加油----", this.Name);
        }
        public Plane(string name) : base(name)
        {

        }
    }
    /// <summary>
    /// -------------------------------------------------------------------------------------------------------------
    /// </summary>

    class Program
    {
        static void Main(string[] args)
        {
            text6();
            Console.ReadKey();
        }
        static void text1()
        {
            //添加3个类，分别实现 IComparer<T>接口，实现对Student类的三个字段的排序。
            //1、学生类：学号、姓名、年龄
            //2、请选择：1、添加学生信息。2、删除学生信息 3、查询学生信息。
            //3、重复的学号不能添加。
            //4、查询学生信息功能中有：1、查询所有（按学号排序）2、查询所有（按姓名排序），
            //2、查询所有（按年龄排序）4、按学号查询（查没有，则打印查无此学生）5、退出
            List<Student> list = new List<Student>();
            //ArrayList list1 = new ArrayList();
            Hashtable list1 = new Hashtable();
            //已有学员
            Student st = new Student(34, "鑫哥", 19);
            Student st1 = new Student(14, "索隆", 30);
            Student st2 = new Student(24, "凯", 25);
            list.Add(st);
            list.Add(st1);
            list.Add(st2);
            list1.Add(st.Stno, st);
            list1.Add(st1.Stno, st1);
            list1.Add(st2.Stno, st2);
        login:
            Console.WriteLine("请选择：1、添加学生信息2、查询学生信息");
            int arr = int.Parse(Console.ReadLine());
            string flag = null;
            switch (arr)
            {
                case 1:
                    while (true)
                    {
                        Console.WriteLine("请添加学生学号：");
                        int a = int.Parse(Console.ReadLine());
                        Console.WriteLine("请添加学生姓名：");
                        string b = Console.ReadLine();
                        Console.WriteLine("请添加学生年龄：");
                        int c = int.Parse(Console.ReadLine());
                        Student st3 = new Student(a, b, c);
                        if (list1.Contains(a))
                        {
                            Console.WriteLine("重复重新输入");
                            goto login;
                        }
                        else
                        {
                            list1.Add(st3.Stno, st3);
                        }
                        Console.WriteLine("要继续吗？(y/n)");
                        flag = Console.ReadLine();
                        if (flag.Equals("n"))
                        {
                            foreach (var t in list1.Keys)
                            {
                                Console.WriteLine(list1[t]);
                            }
                            break;
                        }
                    }
                    break;
                case 2:
                    Console.WriteLine("请选择你要查询的学生信息1、查询所有（按学号排序）2、查询所有（按姓名排序），3、查询所有（按年龄排序）4、按学号查询（查没有，则打印查无此学生）5、退出：");
                    int outing = int.Parse(Console.ReadLine());
                    switch (outing)
                    {
                        case 1:
                            foreach (Student s in list)
                            {
                                Console.WriteLine(s);
                            }

                            list.Sort(new StnoSort());
                            Console.WriteLine("====================");
                            foreach (Student s in list)
                            {
                                Console.WriteLine(s);
                            }
                            break;
                        case 2:
                            foreach (Student s in list)
                            {
                                Console.WriteLine(s);
                            }

                            list.Sort(new NameSort());
                            Console.WriteLine("====================");
                            foreach (Student s in list)
                            {
                                Console.WriteLine(s);
                            }
                            break;
                        case 3:
                            foreach (Student s in list)
                            {
                                Console.WriteLine(s);
                            }

                            list.Sort(new AgeSort());
                            Console.WriteLine("====================");
                            foreach (Student s in list)
                            {
                                Console.WriteLine(s);
                            }
                            break;
                        case 4:
                            Console.WriteLine("请输入你要查的学号：");
                            int find = int.Parse(Console.ReadLine());
                            if (list1.Contains(find))
                            {
                                Console.WriteLine(list1[find]);
                            }
                            else
                            {
                                Console.WriteLine("查无此学生!!!");
                            }
                            break;
                        case 5:
                            Console.WriteLine("正在退出中···");
                            break;
                        default:
                            Console.WriteLine("sb没有该选项，能不能长点脑子？！！");
                            break;
                    }
                    break;
                default:
                    Console.WriteLine("sb没有该选项，能不能长点脑子？！！");
                    break;
            }
        }
        static void text2()
        {
            // 1.定义一个计算图形面积的类，类中定义2个计算面积的方法（重载，方法名相同），分别计算圆面积和长方形面积两个方法。
            // 提示：计算圆的面积传半径，计算长方形面积传长和宽。

            // 2.创建一个名为计算工具类 SumUtils，在类中定义4个方法：
            //     计算两个整数相加、
            //     两个小数相加、 
            //     两个字符串相加、
            //  以及从 1 到指定整数的和的方法。
            // 在 Main 方法中分别调用定义好的方法。

            // 提示：根据题目要求，分别定义 3 个带两个参数的方法，以及一个带一个整型参数的方法，
            //四个方法名相同。
            ASD asd = new ASD();
            double num1 = asd.aaa(3);
            Console.WriteLine("圆面积是：{0}", num1);
            int num2 = asd.aaa(3, 4);
            Console.WriteLine("长方形面积是：{0}", num2);
            Console.WriteLine();

            SumUrils jkl = new SumUrils();
            int a = jkl.AAA(1, 2);
            Console.WriteLine(a);
            double b = jkl.AAA(1.3, 2.3);
            Console.WriteLine(b);
            string c = jkl.AAA("李", "四");
            Console.WriteLine(c);
            int sum = jkl.AAA(5);
            Console.WriteLine(sum);
        }
        static void text3()
        {
            //定义一个员工类，存放用户的工号、姓名、性别、学历和部门信息；
            //定义两个构造函数:
            //一个是无参构造函数，学历默认为专科；
            //一个有参构造函数，根据参数对类的属性进行初始化。
            Employee fgh = new Employee();
            fgh.Id = 1;
            fgh.Name = "张三";
            fgh.Mas = "软件部";
            fgh.aaa();
            fgh.bbb(2, "李四", "设计部");
        }
        static void text4()
        {
            //1、猫、狗、鸭、猴，（吃、游泳、爬树）
            //所有动物都有吃的方法
            //狗和鸭会游泳，不会爬树
            //猫和猴不会游泳会爬树
            //将吃的方法定义在父类方法中，将游泳和爬树的技能定义为接口
            //所有子类继承父类后，再去继承相应的接口实现技能

            void TestSwin(ISwim swim)//static
            {
                swim.Swim();
            }
            void TestClimb(IClimb climb)//static
            {
                climb.Climb();
            }
            void TestEat(IEat eat)//static
            {
                eat.Eat();
            }//static void Main(string[] args)
            Cat cat = new Cat("小咪", "母");
            Dog dog = new Dog("旺财", "公");
            Monkey monkey = new Monkey("泼猴", "公");
            Duck duck = new Duck("呆鸭", "母");
            TestClimb(cat);
            TestEat(cat);
            TestSwin(cat);
            cat.Play();
            Console.WriteLine();
            TestEat(dog);
            TestSwin(dog);
            dog.Play();
            Console.WriteLine();
            TestEat(duck);
            TestSwin(duck);
            duck.Play();
            Console.WriteLine();
            TestClimb(monkey);
            TestEat(monkey);
            monkey.Play();

            //2、蝙蝠战车的例子
            //定义一个父类表示车的共同属性特征行为：品牌名Brand，会跑Run方法
            //定义一个飞的功能接口类IFly：定义飞的方法Fly
            //然后定义蝙蝠战车类继承Cat类和飞的接口
            //在主方法实例化蝙蝠战车的对象，并为品牌名赋值，调用跑和飞的方法

            void TestFire(IFire fire)//static
            {
                fire.Fire();
            }
            void TestFly(IFly fly)//static
            {
                fly.Fly();
            }
            void TestExpedite(IExpedite expedite)//static
            {
                expedite.Expedite();
            }//static void Main(string[] args)
            BMWCar bmwCar1 = new BMWCar("宝马", "750");
            bmwCar1.Run();
            TestExpedite(bmwCar1);
            Console.WriteLine();
            BMWCar bmwCar2 = new BMWCar("宝马", "X5");
            bmwCar2.Run();
            TestExpedite(bmwCar2);
            Console.WriteLine();
            Batmobile batCar = new Batmobile("蝙蝠战车", "第一代");
            batCar.Run();
            batCar.Fly();
            TestExpedite(batCar);
            TestFire(batCar);

            //3、超人、小鸟、飞机

            void TestFly1(IFly1 fly)//static 跟之前题冲突后面加了个1
            {
                fly.Fly();
            }
            void TestLand(ILand land)//static
            {
                land.Land();
            }
            void TestEat1(IEat1 eat)//static 跟之前题冲突后面加了个1
            {
                eat.Eat();
            }//static void Main(string[] args)
            Superman superman = new Superman("派大星");
            Bird bird = new Bird("九日");
            Plane plane = new Plane("王牌");
            TestFly1(superman);
            TestLand(superman);
            TestEat1(superman);
            Console.WriteLine();
            TestFly1(bird);
            TestLand(bird);
            TestEat1(bird);
            Console.WriteLine();
            TestFly1(plane);
            TestLand(plane);
            TestEat1(plane);
            Console.WriteLine();
        }
        static void text5()
        {
            //1.定义一个用户类，存放用户的账号、用户名和密码属性；
            //   在用户类中定义一个方法输出当前用户对象的账号、用户名和密码的信息；然后在主方法调用输出；

            //2.定义一个学生类，存放学生的学号、姓名、性别、年龄、专业信息；
            //   对年龄字段进行赋值的安全性设置，如果是非法值（小于0或者大于128岁），该年龄值为0；
            //   在学生类中定义一个方法输出学生信息。
            //   在主方法实例化对象，赋值并输出

            //3.定义一个图书类，存放图书的编号、书名、价格、出版社、作者信息；
            //  对价格进行赋值限制，小于0价格，赋值为0
            //  在图书类中定义一个方法输出图书信息
            //  在主方法实例化对象，赋值并输出
        }
        static void text6()
        {
            //一、统计下面一段文字中“类”字和“码”的个数。

            //与其他面向对象语言一样，C# 语言也具有面向对象语言的基本特征，即封装、继承、 多态。封装：就是将代码看作一个整体，
            //例如使用类、方法、接口等。在使用定义好的类、 方法、接口等对象时不必考虑其细节，只需要知道其对象名以及所需要的参数即可，
            //也是一种提升代码安全性的方法。继承：是一种体现代码重用性的特性，减少代码的冗余，但在 C# 语言中仅支持单继承。多态：
            //不仅体现了代码的重用性，也体现了代码的灵活性，它主要通过继承和实现接口的方式，让类或接口中的成员表现出不同的作用。

            //1、使用循环遍历的方法来实现。
            //2、使用Replace方法来实现。
            //3、使用Split()方法来实现。

            int classes = 0;
            int ma = 0;
            string arr = "与其他面向对象语言一样，C# 语言也具有面向对象语言的基本特征，即封装、继承、 多态。封装：就是将代码看作一个整体，例如使用类、方法、接口等。在使用定义好的类、 方法、接口等对象时不必考虑其细节，只需要知道其对象名以及所需要的参数即可，也是一种提升代码安全性的方法。继承：是一种体现代码重用性的特性，减少代码的冗余，但在 C# 语言中仅支持单继承。多态：不仅体现了代码的重用性，也体现了代码的灵活性，它主要通过继承和实现接口的方式，让类或接口中的成员表现出不同的作用。";
            foreach (var item in arr)
            {
                if (item.Equals('类'))
                {
                    classes++;
                }
                else if (item.Equals('码'))
                {
                    ma++;
                }
            }
            Console.WriteLine("类{0}，码{1}", classes, ma);


            string strNoLei = arr.Replace("类", "");
            classes = arr.Length - strNoLei.Length;
            Console.WriteLine("类字的个数为" + classes);
            string strNoMa = arr.Replace("码", "");
            ma = arr.Length - strNoMa.Length;
            Console.WriteLine("码字的个数为" + ma);


            char[] b = { '类' };
            string[] c = arr.Split(b);
            int e = 0;
            int h = 0;
            for (int i = 0; i < c.Length; i++)
            {
                e = c[i].Length + e;
            }
            int d = arr.Length - e;
            Console.WriteLine("类" + d);
            char[] f = { '码' };
            string[] g = arr.Split(f);
            for (int i = 0; i < g.Length; i++)
            {
                h = g[i].Length + h;
            }
            int j = arr.Length - h;
            Console.WriteLine("码" + j);

            //二、
            //C# (英 文名为 CSharp) 是 微  软开发的一种 面向对 象的 编程 语言。C# 语言具备了面向对象 语言 的特 征，
            //即封装、继承、多态，并且添加了  事件和委托，增强了 编程的灵 活性。C# 语 言是  一种安全的、稳定的、简 单 的、
            //面向对象的编程 语言 ，其语 法与 C++ 类似，但在编程过  程中要比 C++ 简单；它不仅去掉了 C++ 和 Java 语  言中的一些复杂特性，
            //还提  供了可视化 工具，能够高效地 编写程序。C# 是运行  在.NE  T平台之上的  编程 语言。

            //去掉上面一段文字的所有空格，并统计空格数。
            string arr1 = "C# (英 文名为 CSharp) 是 微  软开发的一种 面向对 象的 编程 语言。C# 语言具备了面向对象 语言 的特 征，  即封装、继承、多态，并且添加了  事件和委托，增强了 编程的灵 活性。C# 语 言是  一种安全的、稳定的、简 单 的、面向对象的编程 语言 ，其语 法与 C++ 类似，但在编程过  程中要比 C++ 简单；它不仅去掉了 C++ 和 Java 语  言中的一些复杂特性，还提  供了可视化 工具，能够高效地 编写程序。C# 是运行  在.NE  T平台之上的  编程 语言。";
            string a = arr1.Replace(" ", "");
            int p = arr1.Length - a.Length;
            Console.WriteLine("空格数{0}", p);

        }
    }
}
